home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1998 July / EnigmA AMIGA RUN 29 (1998)(G.R. Edizioni)(IT)[!][issue 1998-07 & 08].iso / earkit / socket / miami3 / miamisdk / netinclude / ppcpragmas / socket_pragmas.h < prev    next >
C/C++ Source or Header  |  1998-05-24  |  20KB  |  723 lines
  1. #ifndef _PPCPRAGMA_SOCKET_H
  2. #define _PPCPRAGMA_SOCKET_H
  3.  
  4. #ifndef POWERUP_PPCLIB_INTERFACE_H
  5. #include <powerup/ppclib/interface.h>
  6. #endif
  7.  
  8. #ifndef POWERUP_GCCLIB_PROTOS_H
  9. #include <powerup/gcclib/powerup_protos.h>
  10. #endif
  11.  
  12. #ifndef _STRING_H
  13. #include <string.h>
  14. #endif
  15.  
  16. #ifndef NO_PPCINLINE_STDARG
  17. #define NO_PPCINLINE_STDARG
  18. #endif/* SAS C PPC inlines */
  19.  
  20. #ifndef SOCKET_BASE_NAME
  21. #define SOCKET_BASE_NAME SocketBase
  22. #endif
  23.  
  24. #define socket(d,t,p) _socket(SOCKET_BASE_NAME,d,t,p)
  25.  
  26. static __inline long
  27. _socket(void *SocketBase,long d,long t,long p) {
  28.     struct Caos MyCaos;
  29.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  30.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  31.     MyCaos.d0=(ULONG)d;
  32.     MyCaos.d1=(ULONG)t;
  33.     MyCaos.d2=(ULONG)p;
  34.     MyCaos.caos_Un.Offset=-30;
  35.     MyCaos.a6=(ULONG)SocketBase;
  36.     return (long)PPCCallOS(&MyCaos);
  37. }
  38.  
  39. #define bind(s,n,nl) _bind(SOCKET_BASE_NAME,s,n,nl)
  40.  
  41. static __inline long
  42. _bind(void *SocketBase,long s,const struct sockaddr *n,long nl) {
  43.     struct Caos MyCaos;
  44.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  45.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  46.     MyCaos.d0=(ULONG)s;
  47.     MyCaos.a0=(ULONG)n;
  48.     MyCaos.d1=(ULONG)nl;
  49.     MyCaos.caos_Un.Offset=-36;
  50.     MyCaos.a6=(ULONG)SocketBase;
  51.     return (long)PPCCallOS(&MyCaos);
  52. }
  53.  
  54. #define listen(s,b) _listen(SOCKET_BASE_NAME,s,b)
  55.  
  56. static __inline long
  57. _listen(void *SocketBase,long s,long b) {
  58.     struct Caos MyCaos;
  59.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  60.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  61.     MyCaos.d0=(ULONG)s;
  62.     MyCaos.d1=(ULONG)b;
  63.     MyCaos.caos_Un.Offset=-42;
  64.     MyCaos.a6=(ULONG)SocketBase;
  65.     return (long)PPCCallOS(&MyCaos);
  66. }
  67.  
  68. #define accept(s,a,al) _accept(SOCKET_BASE_NAME,s,a,al)
  69.  
  70. static __inline long
  71. _accept(void *SocketBase,long s,struct sockaddr *a,long *al) {
  72.     struct Caos MyCaos;
  73.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  74.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  75.     MyCaos.d0=(ULONG)s;
  76.     MyCaos.a0=(ULONG)a;
  77.     MyCaos.a1=(ULONG)al;
  78.     MyCaos.caos_Un.Offset=-48;
  79.     MyCaos.a6=(ULONG)SocketBase;
  80.     return (long)PPCCallOS(&MyCaos);
  81. }
  82.  
  83. #define connect(s,n,nl) _connect(SOCKET_BASE_NAME,s,n,nl)
  84.  
  85. static __inline long
  86. _connect(void *SocketBase,long s,struct sockaddr *n,long nl) {
  87.     struct Caos MyCaos;
  88.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  89.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  90.     MyCaos.d0=(ULONG)s;
  91.     MyCaos.a0=(ULONG)n;
  92.     MyCaos.d1=(ULONG)nl;
  93.     MyCaos.caos_Un.Offset=-54;
  94.     MyCaos.a6=(ULONG)SocketBase;
  95.     return (long)PPCCallOS(&MyCaos);
  96. }
  97.  
  98. #define sendto(s,m,l,f,t,tl) _sendto(SOCKET_BASE_NAME,s,m,l,f,t,tl)
  99.  
  100. static __inline long
  101. _sendto(void *SocketBase,long s,const unsigned char *m,long l,long f,
  102.  const struct sockaddr *t,long tl) {
  103.     struct Caos MyCaos;
  104.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  105.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  106.     MyCaos.d0=(ULONG)s;
  107.     MyCaos.a0=(ULONG)m;
  108.     MyCaos.d1=(ULONG)l;
  109.     MyCaos.d2=(ULONG)f;
  110.     MyCaos.a1=(ULONG)t;
  111.     MyCaos.d3=(ULONG)tl;
  112.     MyCaos.caos_Un.Offset=-60;
  113.     MyCaos.a6=(ULONG)SocketBase;
  114.     return (long)PPCCallOS(&MyCaos);
  115. }
  116.  
  117. #define send(s,m,l,f) _send(SOCKET_BASE_NAME,s,m,l,f)
  118.  
  119. static __inline long
  120. _send(void *SocketBase,long s,const unsigned char *m,long l,long f) {
  121.     struct Caos MyCaos;
  122.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  123.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  124.     MyCaos.d0=(ULONG)s;
  125.     MyCaos.a0=(ULONG)m;
  126.     MyCaos.d1=(ULONG)l;
  127.     MyCaos.d2=(ULONG)f;
  128.     MyCaos.caos_Un.Offset=-66;
  129.     MyCaos.a6=(ULONG)SocketBase;
  130.     return (long)PPCCallOS(&MyCaos);
  131. }
  132.  
  133. #define recvfrom(s,b,l,f,fr,frl) _recvfrom(SOCKET_BASE_NAME,s,b,l,f,fr,frl)
  134.  
  135. static __inline long
  136. _recvfrom(void *SocketBase,long s,unsigned char *b,long l,long f,
  137.  struct sockaddr *fr,long *frl) {
  138.     struct Caos MyCaos;
  139.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  140.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  141.     MyCaos.d0=(ULONG)s;
  142.     MyCaos.a0=(ULONG)b;
  143.     MyCaos.d1=(ULONG)l;
  144.     MyCaos.d2=(ULONG)f;
  145.     MyCaos.a1=(ULONG)fr;
  146.     MyCaos.a2=(ULONG)frl;
  147.     MyCaos.caos_Un.Offset=-72;
  148.     MyCaos.a6=(ULONG)SocketBase;
  149.     return (long)PPCCallOS(&MyCaos);
  150. }
  151.  
  152. #define recv(s,b,l,f) _recv(SOCKET_BASE_NAME,s,b,l,f)
  153.  
  154. static __inline long
  155. _recv(void *SocketBase,long s,unsigned char *b,long l,long f) {
  156.     struct Caos MyCaos;
  157.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  158.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  159.     MyCaos.PPCStart=b;
  160.     MyCaos.PPCLength=l;
  161.     MyCaos.d0=(ULONG)s;
  162.     MyCaos.a0=(ULONG)b;
  163.     MyCaos.d1=(ULONG)l;
  164.     MyCaos.d2=(ULONG)f;
  165.     MyCaos.caos_Un.Offset=-78;
  166.     MyCaos.a6=(ULONG)SocketBase;
  167.     return (long)PPCCallOS(&MyCaos);
  168. }
  169.  
  170. #define shutdown(s,h) _shutdown(SOCKET_BASE_NAME,s,h)
  171.  
  172. static __inline long
  173. _shutdown(void *SocketBase,long s,long h) {
  174.     struct Caos MyCaos;
  175.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  176.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  177.     MyCaos.d0=(ULONG)s;
  178.     MyCaos.d1=(ULONG)h;
  179.     MyCaos.caos_Un.Offset=-84;
  180.     MyCaos.a6=(ULONG)SocketBase;
  181.     return (long)PPCCallOS(&MyCaos);
  182. }
  183.  
  184. #define setsockopt(s,l,o,ov,ol) _setsockopt(SOCKET_BASE_NAME,s,l,o,ov,ol)
  185.  
  186. static __inline long
  187. _setsockopt(void *SocketBase,long s,long l,long o,const void *ov,long ol) {
  188.     struct Caos MyCaos;
  189.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  190.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  191.     MyCaos.d0=(ULONG)s;
  192.     MyCaos.d1=(ULONG)l;
  193.     MyCaos.d2=(ULONG)o;
  194.     MyCaos.a0=(ULONG)ov;
  195.     MyCaos.d3=(ULONG)ol;
  196.     MyCaos.caos_Un.Offset=-90;
  197.     MyCaos.a6=(ULONG)SocketBase;
  198.     return (long)PPCCallOS(&MyCaos);
  199. }
  200.  
  201. #define getsockopt(s,l,o,ov,ol) _getsockopt(SOCKET_BASE_NAME,s,l,o,ov,ol)
  202.  
  203. static __inline long
  204. _getsockopt(void *SocketBase,long s,long l,long o,const void *ov,long *ol) {
  205.     struct Caos MyCaos;
  206.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  207.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  208.     MyCaos.d0=(ULONG)s;
  209.     MyCaos.d1=(ULONG)l;
  210.     MyCaos.d2=(ULONG)o;
  211.     MyCaos.a0=(ULONG)ov;
  212.     MyCaos.a1=(ULONG)ol;
  213.     MyCaos.caos_Un.Offset=-96;
  214.     MyCaos.a6=(ULONG)SocketBase;
  215.     return (long)PPCCallOS(&MyCaos);
  216. }
  217.  
  218. #define getsockname(s,h,n) _getsockname(SOCKET_BASE_NAME,s,h,n)
  219.  
  220. static __inline long
  221. _getsockname(void *SocketBase,long s,struct sockaddr *h,long *n) {
  222.     struct Caos MyCaos;
  223.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  224.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  225.     MyCaos.d0=(ULONG)s;
  226.     MyCaos.a0=(ULONG)h;
  227.     MyCaos.a1=(ULONG)n;
  228.     MyCaos.caos_Un.Offset=-102;
  229.     MyCaos.a6=(ULONG)SocketBase;
  230.     return (long)PPCCallOS(&MyCaos);
  231. }
  232.  
  233. #define getpeername(s,h,n) _getpeername(SOCKET_BASE_NAME,s,h,n)
  234.  
  235. static __inline long
  236. _getpeername(void *SocketBase,long s,struct sockaddr *h,long *n) {
  237.     struct Caos MyCaos;
  238.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  239.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  240.     MyCaos.d0=(ULONG)s;
  241.     MyCaos.a0=(ULONG)h;
  242.     MyCaos.a1=(ULONG)n;
  243.     MyCaos.caos_Un.Offset=-108;
  244.     MyCaos.a6=(ULONG)SocketBase;
  245.     return (long)PPCCallOS(&MyCaos);
  246. }
  247.  
  248. #define IoctlSocket(d,r,a) _IoctlSocket(SOCKET_BASE_NAME,d,r,a)
  249.  
  250. static __inline long
  251. _IoctlSocket(void *SocketBase,long d,unsigned long r,char *a) {
  252.     struct Caos MyCaos;
  253.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  254.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  255.     MyCaos.d0=(ULONG)d;
  256.     MyCaos.d1=(ULONG)r;
  257.     MyCaos.a0=(ULONG)a;
  258.     MyCaos.caos_Un.Offset=-114;
  259.     MyCaos.a6=(ULONG)SocketBase;
  260.     return (long)PPCCallOS(&MyCaos);
  261. }
  262.  
  263. #define CloseSocket(d) _CloseSocket(SOCKET_BASE_NAME,d)
  264.  
  265. static __inline long
  266. _CloseSocket(void *SocketBase,long d) {
  267.     struct Caos MyCaos;
  268.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  269.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  270.     MyCaos.d0=(ULONG)d;
  271.     MyCaos.caos_Un.Offset=-120;
  272.     MyCaos.a6=(ULONG)SocketBase;
  273.     return (long)PPCCallOS(&MyCaos);
  274. }
  275.  
  276. #define WaitSelect(n,r,w,e,t,m) _WaitSelect(SOCKET_BASE_NAME,n,r,w,e,t,m)
  277. #define select(n,r,w,e,t) _WaitSelect(SOCKET_BASE_NAME,n,r,w,e,t,0)
  278.  
  279. static __inline long
  280. _WaitSelect(void *SocketBase,long n,fd_set *r,fd_set *w,fd_set *e,
  281.  void *t,unsigned long *m) {
  282.     struct Caos MyCaos;
  283.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  284.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  285.     MyCaos.d0=(ULONG)n;
  286.     MyCaos.a0=(ULONG)r;
  287.     MyCaos.a1=(ULONG)w;
  288.     MyCaos.a2=(ULONG)e;
  289.     MyCaos.a3=(ULONG)t;
  290.     MyCaos.d1=(ULONG)m;
  291.     MyCaos.caos_Un.Offset=-126;
  292.     MyCaos.a6=(ULONG)SocketBase;
  293.     return (long)PPCCallOS(&MyCaos);
  294. }
  295.  
  296. #define SetSocketSignals(sin,sio,su) _SetSocketSignals(SOCKET_BASE_NAME,sin,sio,su)
  297.  
  298. static __inline void
  299. _SetSocketSignals(void *SocketBase,unsigned long sin,unsigned long sio,
  300.  unsigned long su) {
  301.     struct Caos MyCaos;
  302.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  303.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  304.     MyCaos.d0=(ULONG)sin;
  305.     MyCaos.d1=(ULONG)sio;
  306.     MyCaos.d2=(ULONG)su;
  307.     MyCaos.caos_Un.Offset=-132;
  308.     MyCaos.a6=(ULONG)SocketBase;
  309.     PPCCallOS(&MyCaos);
  310. }
  311.  
  312. #define getdtablesize() _getdtablesize(SOCKET_BASE_NAME)
  313.  
  314. static __inline long
  315. _getdtablesize(void *SocketBase) {
  316.     struct Caos MyCaos;
  317.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  318.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  319.     MyCaos.caos_Un.Offset=-138;
  320.     MyCaos.a6=(ULONG)SocketBase;
  321.     return (long)PPCCallOS(&MyCaos);
  322. }
  323.  
  324. #define ObtainSocket(i,d,t,p) _ObtainSocket(SOCKET_BASE_NAME,i,d,t,p)
  325.  
  326. static __inline long
  327. _ObtainSocket(void *SocketBase,long i,long d,long t,long p) {
  328.     struct Caos MyCaos;
  329.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  330.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  331.     MyCaos.d0=(ULONG)i;
  332.     MyCaos.d1=(ULONG)d;
  333.     MyCaos.d2=(ULONG)t;
  334.     MyCaos.d3=(ULONG)p;
  335.     MyCaos.caos_Un.Offset=-144;
  336.     MyCaos.a6=(ULONG)SocketBase;
  337.     return (long)PPCCallOS(&MyCaos);
  338. }
  339.  
  340. #define ReleaseSocket(f,i) _ReleaseSocket(SOCKET_BASE_NAME,f,i)
  341.  
  342. static __inline long
  343. _ReleaseSocket(void *SocketBase,long f,long i) {
  344.     struct Caos MyCaos;
  345.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  346.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  347.     MyCaos.d0=(ULONG)f;
  348.     MyCaos.d1=(ULONG)i;
  349.     MyCaos.caos_Un.Offset=-150;
  350.     MyCaos.a6=(ULONG)SocketBase;
  351.     return (long)PPCCallOS(&MyCaos);
  352. }
  353.  
  354. #define ReleaseCopyOfSocket(f,i) _ReleaseCopyOfSocket(SOCKET_BASE_NAME,f,i)
  355.  
  356. static __inline long
  357. _ReleaseCopyOfSocket(void *SocketBase,long f,long i) {
  358.     struct Caos MyCaos;
  359.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  360.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  361.     MyCaos.d0=(ULONG)f;
  362.     MyCaos.d1=(ULONG)i;
  363.     MyCaos.caos_Un.Offset=-156;
  364.     MyCaos.a6=(ULONG)SocketBase;
  365.     return (long)PPCCallOS(&MyCaos);
  366. }
  367.  
  368. #define Errno() _Errno(SOCKET_BASE_NAME)
  369.  
  370. static __inline long
  371. _Errno(void *SocketBase) {
  372.     struct Caos MyCaos;
  373.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  374.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  375.     MyCaos.caos_Un.Offset=-162;
  376.     MyCaos.a6=(ULONG)SocketBase;
  377.     return (long)PPCCallOS(&MyCaos);
  378. }
  379.  
  380. #define SetErrnoPtr(e,s) _SetErrnoPtr(SOCKET_BASE_NAME,e,s)
  381.  
  382. static __inline long
  383. _SetErrnoPtr(void *SocketBase,long *e,long s) {
  384.     struct Caos MyCaos;
  385.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  386.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  387.     MyCaos.a0=(ULONG)e;
  388.     MyCaos.d0=(ULONG)s;
  389.     MyCaos.caos_Un.Offset=-168;
  390.     MyCaos.a6=(ULONG)SocketBase;
  391.     return (long)PPCCallOS(&MyCaos);
  392. }
  393.  
  394. #define Inet_NtoA(i) _Inet_NtoA(SOCKET_BASE_NAME,i)
  395. #define inet_ntoa(i) _Inet_NtoA(SOCKET_BASE_NAME,(i).s_addr)
  396.  
  397. static __inline char *
  398. _Inet_NtoA(void *SocketBase,unsigned long i) {
  399.     struct Caos MyCaos;
  400.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  401.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  402.     MyCaos.d0=(ULONG)i;
  403.     MyCaos.caos_Un.Offset=-174;
  404.     MyCaos.a6=(ULONG)SocketBase;
  405.     return (char *)PPCCallOS(&MyCaos);
  406. }
  407.  
  408. #define inet_addr(c) _inet_addr(SOCKET_BASE_NAME,c)
  409.  
  410. static __inline unsigned long
  411. _inet_addr(void *SocketBase,const unsigned char *c) {
  412.     struct Caos MyCaos;
  413.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  414.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  415.     MyCaos.a0=(ULONG)c;
  416.     MyCaos.caos_Un.Offset=-180;
  417.     MyCaos.a6=(ULONG)SocketBase;
  418.     return (unsigned long)PPCCallOS(&MyCaos);
  419. }
  420.  
  421. #define Inet_LnaOf(i) _Inet_LnaOf(SOCKET_BASE_NAME,i)
  422. #define inet_lnaof(i) _Inet_LnaOf(SOCKET_BASE_NAME,(i).s_addr)
  423.  
  424. static __inline unsigned long
  425. _Inet_LnaOf(void *SocketBase,long i) {
  426.     struct Caos MyCaos;
  427.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  428.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  429.     MyCaos.d0=(ULONG)i;
  430.     MyCaos.caos_Un.Offset=-186;
  431.     MyCaos.a6=(ULONG)SocketBase;
  432.     return (unsigned long)PPCCallOS(&MyCaos);
  433. }
  434.  
  435. #define Inet_NetOf(i) _Inet_NetOf(SOCKET_BASE_NAME,i)
  436. #define inet_netof(i) _Inet_NetOf(SOCKET_BASE_NAME,(i).s_addr)
  437.  
  438. static __inline unsigned long
  439. _Inet_NetOf(void *SocketBase,long i) {
  440.     struct Caos MyCaos;
  441.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  442.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  443.     MyCaos.d0=(ULONG)i;
  444.     MyCaos.caos_Un.Offset=-192;
  445.     MyCaos.a6=(ULONG)SocketBase;
  446.     return (unsigned long)PPCCallOS(&MyCaos);
  447. }
  448.  
  449. #define Inet_MakeAddr(n,h) _Inet_MakeAddr(SOCKET_BASE_NAME,n,h)
  450.  
  451. static __inline unsigned long
  452. _Inet_MakeAddr(void *SocketBase,unsigned long n,unsigned long h) {
  453.     struct Caos MyCaos;
  454.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  455.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  456.     MyCaos.d0=(ULONG)n;
  457.     MyCaos.d1=(ULONG)h;
  458.     MyCaos.caos_Un.Offset=-198;
  459.     MyCaos.a6=(ULONG)SocketBase;
  460.     return (unsigned long)PPCCallOS(&MyCaos);
  461. }
  462.  
  463. #define inet_makeaddr(n,h) _inet_makeaddr(SOCKET_BASE_NAME,n,h)
  464.  
  465. static __inline struct in_addr
  466. _inet_makeaddr(void *SocketBase,unsigned long n,unsigned long h) {
  467.     struct in_addr addr;
  468.     struct Caos MyCaos;
  469.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  470.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  471.     MyCaos.d0=(ULONG)n;
  472.     MyCaos.d1=(ULONG)h;
  473.     MyCaos.caos_Un.Offset=-198;
  474.     MyCaos.a6=(ULONG)SocketBase;
  475.     addr.s_addr=(unsigned long)PPCCallOS(&MyCaos);
  476.     return addr;
  477. }
  478.  
  479. #define inet_network(c) _inet_network(SOCKET_BASE_NAME,c)
  480.  
  481. static __inline unsigned long
  482. _inet_network(void *SocketBase,long c) {
  483.     struct Caos MyCaos;
  484.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  485.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  486.     MyCaos.a0=(ULONG)c;
  487.     MyCaos.caos_Un.Offset=-204;
  488.     MyCaos.a6=(ULONG)SocketBase;
  489.     return (unsigned long)PPCCallOS(&MyCaos);
  490. }
  491.  
  492. #define gethostbyname(n) _gethostbyname(SOCKET_BASE_NAME,n)
  493.  
  494. static __inline struct hostent *
  495. _gethostbyname(void *SocketBase,const unsigned char *n) {
  496.     struct Caos MyCaos;
  497.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  498.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  499.     MyCaos.a0=(ULONG)n;
  500.     MyCaos.caos_Un.Offset=-210;
  501.     MyCaos.a6=(ULONG)SocketBase;
  502.     return (struct hostent *)PPCCallOS(&MyCaos);
  503. }
  504.  
  505. #define gethostbyaddr(a,l,t) _gethostbyaddr(SOCKET_BASE_NAME,a,l,t)
  506.  
  507. static __inline struct hostent *
  508. _gethostbyaddr(void *SocketBase,const unsigned char *a,long l,long t) {
  509.     struct Caos MyCaos;
  510.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  511.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  512.     MyCaos.a0=(ULONG)a;
  513.     MyCaos.d0=(ULONG)l;
  514.     MyCaos.d1=(ULONG)t;
  515.     MyCaos.caos_Un.Offset=-216;
  516.     MyCaos.a6=(ULONG)SocketBase;
  517.     return (struct hostent *)PPCCallOS(&MyCaos);
  518. }
  519.  
  520. #define getnetbyname(n) _getnetbyname(SOCKET_BASE_NAME,n)
  521.  
  522. static __inline struct netent *
  523. _getnetbyname(void *SocketBase,const unsigned char *n) {
  524.     struct Caos MyCaos;
  525.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  526.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  527.     MyCaos.a0=(ULONG)n;
  528.     MyCaos.caos_Un.Offset=-222;
  529.     MyCaos.a6=(ULONG)SocketBase;
  530.     return (struct netent *)PPCCallOS(&MyCaos);
  531. }
  532.  
  533. #define getnetbyaddr(n,t) _getnetbyaddr(SOCKET_BASE_NAME,n,t)
  534.  
  535. static __inline struct netent *
  536. _getnetbyaddr(void *SocketBase,long n,long t) {
  537.     struct Caos MyCaos;
  538.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  539.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  540.     MyCaos.d0=(ULONG)n;
  541.     MyCaos.d1=(ULONG)t;
  542.     MyCaos.caos_Un.Offset=-228;
  543.     MyCaos.a6=(ULONG)SocketBase;
  544.     return (struct netent *)PPCCallOS(&MyCaos);
  545. }
  546.  
  547. #define getservbyname(n,p) _getservbyname(SOCKET_BASE_NAME,n,p)
  548.  
  549. static __inline struct servent *
  550. _getservbyname(void *SocketBase,const unsigned char *n,const unsigned char *p) {
  551.     struct Caos MyCaos;
  552.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  553.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  554.     MyCaos.a0=(ULONG)n;
  555.     MyCaos.a1=(ULONG)p;
  556.     MyCaos.caos_Un.Offset=-234;
  557.     MyCaos.a6=(ULONG)SocketBase;
  558.     return (struct servent *)PPCCallOS(&MyCaos);
  559. }
  560.  
  561. #define getservbyport(p,pr) _getservbyport(SOCKET_BASE_NAME,p,pr)
  562.  
  563. static __inline struct servent *
  564. _getservbyport(void *SocketBase,long p,const unsigned char *pr) {
  565.     struct Caos MyCaos;
  566.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  567.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  568.     MyCaos.d0=(ULONG)p;
  569.     MyCaos.a0=(ULONG)pr;
  570.     MyCaos.caos_Un.Offset=-240;
  571.     MyCaos.a6=(ULONG)SocketBase;
  572.     return (struct servent *)PPCCallOS(&MyCaos);
  573. }
  574.  
  575. #define getprotobyname(n) _getprotobyname(SOCKET_BASE_NAME,n)
  576.  
  577. static __inline struct protoent *
  578. _getprotobyname(void *SocketBase,const unsigned char *n) {
  579.     struct Caos MyCaos;
  580.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  581.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  582.     MyCaos.a0=(ULONG)n;
  583.     MyCaos.caos_Un.Offset=-246;
  584.     MyCaos.a6=(ULONG)SocketBase;
  585.     return (struct protoent *)PPCCallOS(&MyCaos);
  586. }
  587.  
  588. #define getprotobynumber(p) _getprotobynumber(SOCKET_BASE_NAME,p)
  589.  
  590. static __inline struct protoent *
  591. _getprotobynumber(void *SocketBase,long p) {
  592.     struct Caos MyCaos;
  593.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  594.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  595.     MyCaos.d0=(ULONG)p;
  596.     MyCaos.caos_Un.Offset=-252;
  597.     MyCaos.a6=(ULONG)SocketBase;
  598.     return (struct protoent *)PPCCallOS(&MyCaos);
  599. }
  600.  
  601. #define vsyslog(l,f,a) _vsyslog(SOCKET_BASE_NAME,l,f,a)
  602.  
  603. static __inline void
  604. _vsyslog(void *SocketBase,unsigned long l,const char *f,long *a) {
  605.     struct Caos MyCaos;
  606.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  607.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  608.     MyCaos.d0=(ULONG)l;
  609.     MyCaos.a0=(ULONG)f;
  610.     MyCaos.a1=(ULONG)a;
  611.     MyCaos.caos_Un.Offset=-258;
  612.     MyCaos.a6=(ULONG)SocketBase;
  613.     PPCCallOS(&MyCaos);
  614. }
  615.  
  616. #ifndef NO_PPCINLINE_STDARG
  617. #define syslog(l, f, tags...) \
  618.     ({ULONG _tags[] = {tags}; vsyslog((l), (f), (long) _tags);})
  619. #endif
  620.  
  621. #define Dup2Socket(fa,fb) _Dup2Socket(SOCKET_BASE_NAME,fa,fb)
  622.  
  623. static __inline long
  624. _Dup2Socket(void *SocketBase,long fa,long fb) {
  625.     struct Caos MyCaos;
  626.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  627.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  628.     MyCaos.d0=(ULONG)fa;
  629.     MyCaos.d1=(ULONG)fb;
  630.     MyCaos.caos_Un.Offset=-264;
  631.     MyCaos.a6=(ULONG)SocketBase;
  632.     return (long)PPCCallOS(&MyCaos);
  633. }
  634.  
  635. #define sendmsg(s,m,f) _sendmsg(SOCKET_BASE_NAME,s,m,f)
  636.  
  637. static __inline long
  638. _sendmsg(void *SocketBase,long s,struct msghdr *m,long f) {
  639.     struct Caos MyCaos;
  640.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  641.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  642.     MyCaos.d0=(ULONG)s;
  643.     MyCaos.a0=(ULONG)m;
  644.     MyCaos.d1=(ULONG)f;
  645.     MyCaos.caos_Un.Offset=-270;
  646.     MyCaos.a6=(ULONG)SocketBase;
  647.     return (long)PPCCallOS(&MyCaos);
  648. }
  649.  
  650. #define recvmsg(s,m,f) _recvmsg(SOCKET_BASE_NAME,s,m,f)
  651.  
  652. static __inline long
  653. _recvmsg(void *SocketBase,long s,struct msghdr *m,long f) {
  654.     struct Caos MyCaos;
  655.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  656.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  657.     MyCaos.d0=(ULONG)s;
  658.     MyCaos.a0=(ULONG)m;
  659.     MyCaos.d1=(ULONG)f;
  660.     MyCaos.caos_Un.Offset=-276;
  661.     MyCaos.a6=(ULONG)SocketBase;
  662.     return (long)PPCCallOS(&MyCaos);
  663. }
  664.  
  665. #define gethostname(h,s) _gethostname(SOCKET_BASE_NAME,h,s)
  666.  
  667. static __inline long
  668. _gethostname(void *SocketBase,char *h,long s) {
  669.     struct Caos MyCaos;
  670.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  671.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  672.     MyCaos.a0=(ULONG)h;
  673.     MyCaos.d0=(ULONG)s;
  674.     MyCaos.caos_Un.Offset=-282;
  675.     MyCaos.a6=(ULONG)SocketBase;
  676.     return (long)PPCCallOS(&MyCaos);
  677. }
  678.  
  679. #define gethostid() _gethostid(SOCKET_BASE_NAME)
  680.  
  681. static __inline unsigned long
  682. _gethostid(void *SocketBase) {
  683.     struct Caos MyCaos;
  684.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  685.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  686.     MyCaos.caos_Un.Offset=-288;
  687.     MyCaos.a6=(ULONG)SocketBase;
  688.     return (unsigned long)PPCCallOS(&MyCaos);
  689. }
  690.  
  691. #define SocketBaseTagList(t) _SocketBaseTagList(SOCKET_BASE_NAME,t)
  692.  
  693. static __inline long
  694. _SocketBaseTagList(void *SocketBase,struct TagItem *t) {
  695.     struct Caos MyCaos;
  696.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  697.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  698.     MyCaos.a0=(ULONG)t;
  699.     MyCaos.caos_Un.Offset=-294;
  700.     MyCaos.a6=(ULONG)SocketBase;
  701.     return (long)PPCCallOS(&MyCaos);
  702. }
  703.  
  704. #ifndef NO_PPCINLINE_STDARG
  705. #define SocketBaseTags(tags...) \
  706.     ({ULONG _tags[] = {tags}; SocketBaseTagList((struct TagItem *)_tags);})
  707. #endif
  708.  
  709. #define GetSocketEvents(e) _GetSocketEvents(SOCKET_BASE_NAME,e)
  710.  
  711. static __inline long
  712. _GetSocketEvents(void *SocketBase,unsigned long *e) {
  713.     struct Caos MyCaos;
  714.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  715.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  716.     MyCaos.a0=(ULONG)e;
  717.     MyCaos.caos_Un.Offset=-300;
  718.     MyCaos.a6=(ULONG)SocketBase;
  719.     return (long)PPCCallOS(&MyCaos);
  720. }
  721.  
  722. #endif
  723.